<?php

/**
 * Kézzel megcsinálva.
 *
 * @author poli
 *
 */
class DBSiteUser extends DBObject {

	/**
	 * A tábla definíció, ami alapján a class működik
	 * @var DBTable
	 */
	private static $_dbTable = null;

	/**
	 * Field nevek tömbje, alapértelmezésben ezeket a field-eket nem rakja bele a form definíciókba
	 * @var array
	 */
	private static $_skipTableFieldsInForms = null;

	/**
	 * Req-resp loop object cache objektum
	 * @var DBObjectStore
	 */
	private static $_objectStore = null;


	protected $id;
	protected $siteId;
	protected $name;
	protected $language;
	protected $email;
	protected $password;
	protected $gender;
	protected $birthyear;
	protected $type;
	protected $status;
	protected $rights;
	protected $texts;


	public function DBSiteUser() {
		parent::DBObject(DBSiteUser::getDBTable());
	}


	/**
	 * Az átadott db rekord alapján feltölti az objektum mezőit
	 *
	 * @param array $record a db rekord
	 * @return DBSiteUser
	 */
	protected function fillFromDBRecord(&$record) {
		parent::fillFromDBRecord($record, DBSiteUser::getDBTable());
	}

	/**
	 * Menti a változásokat a db-be.
	 * A mentés előtt a shouldSave() hívással megvizsgálja (DBObject metódus, felülírható!), hogy kell-e menteni egyáltalán.
	 * Ha igen, akkor még a mentés előtt a checkFields() hívással (DBObject metódus, felülírható!) ellenőrizteti a mezőket.
	 * És ha ez sem ad vissza semmit, akkor megy a mentés!
	 *
	 * FONTOS! Ha a rekord új rekord volt, akkor sikeres mentést követően az átadott $cacheControl függvényében
	 * rögtön be is kerül a cache-be! Az alapértelmezés az, hogy bekerül!
	 *
	 * @param boolean $forceFullSave ha true, akkor minden mező mentésre kerül - függetlenül attól hogy változott-e
	 * @param int $cacheControl ha null, akkor normál cache működés van (új rekord sikeres mentés után bekerül a cache-be), vagy valamelyik CACHECONTROL_xxx konstans, ha spéci cache kezelést akarsz
	 * @return array nyelvesített mező hibaüzenetek tömbje, vagy null ha minden oké!
	 * @throws Exception súlyos hiba esetén nyelvesített exception-t ad vissza
	 * @see shouldSave()
	 * @see checkFields()
	 */
	public function save($forceFullSave = false, $cacheControl = null) {
		return parent::save(DBSiteUser::getDBTable(), 'DBSiteUser', $forceFullSave, $cacheControl);
	}

	/**
	 * Törli az objektumot a db-ből, és ha van cache angedélyezve akkor onnan is. A törlés azonnal megtörténik.
	 * Törölt objektum mezői és minden szara persze továbbra is még él, de pl. save()-elni már nem lehet - pontosabban
	 * lehet, de nem fog a save csinálni semmit már.
	 *
	 * @param int $cacheControl ha null, akkor normál cache működés van (rekord sikeres törlése után töröljük a cache-ből), vagy valamelyik CACHECONTROL_xxx konstans, ha spéci cache kezelést akarsz
	 * @return array nyelvesített hibaüzenetek tömbje, vagy null ha minden oké!
	 * @throws Exception súlyos hiba esetén nyelvesített exception megy
	 */
	public function delete($cacheControl = null) {
		return parent::delete(DBSiteUser::getDBTable(), 'DBSiteUser', $cacheControl);
	}


	/**
	 * Visszaadja a class DBTable definícióját, ami alapján működik
	 * @return DBTable
	 */
	public static function getDBTable() {
		if(is_null(DBSiteUser::$_dbTable)) {
			DBSiteUser::$_dbTable = new DBTable('siteuser', DBTable::STANDARD_ID_KEY, array(
					'id' => new DBField('db_field_id', 'i'),
					'siteId' => new DBField('db_field_siteId', 'i', 'site_id'),
					'name' => new DBField('db_siteuser_field_name'),
					'language' => new DBField('db_siteuser_field_language'),
					'email' => new DBField('db_siteuser_field_email'),
					'password' => new DBField('db_siteuser_field_password'),
					'gender' => new DBField('db_siteuser_field_gender'),
					'birthyear' => new DBField('db_siteuser_field_birthyear', 'i'),
					'type' => new DBField('db_field_type', 'i'),
					'status' => new DBField('db_field_status', 'i'),
					'rights' => new DBField('db_siteuser_field_rights', 'i'),
					'attributes' => new DBField(null, 'a'),
					'texts' => new DBField(null, 'a'),
			));
		}
			
		return DBSiteUser::$_dbTable;
	}

	/**
	 * Field nevek tömbje, alapértelmezésben ezeket a field-eket nem rakja bele a form definíciókba - a mapping config
	 * fájl tartalmazhatja, az ObjectMapping objektumból jön ez ide
	 * @var array
	 */
	public static function getSkipFieldsInForms() {
		if(is_null(DBSiteUser::$_skipTableFieldsInForms)) {
			DBSiteUser::$_skipTableFieldsInForms = array('id', 'attributes', 'texts');
		}
		return DBSiteUser::$_skipTableFieldsInForms;
	}


	private function __________cacheHandling(){
	}

	/**
	 * Visszaadja az objektumokat cache-elő objektum tárolót
	 *
	 * @return DBObjectStore
	 */
	public static function getObjectStore() {
		if(is_null(DBSiteUser::$_objectStore))
		DBSiteUser::$_objectStore = new DBObjectStore('DBSiteUser');

		return DBSiteUser::$_objectStore;
	}


	private function __________customMethods(){
	}



	private function __________forms(){
	}


	/**
	 * Létrehoz egy Form objektumot (form definíció), és visszaadja azt anélkül, hogy hozzáadná a FormUtil-lal
	 * a rendszerhez.
	 * A Form-ban a mezők típusai összhangban vannak a tábla definícióval.
	 * A mezők nevei pedig megfelelnek a field-ek neveinek.
	 *
	 * Az nyilván triviális, hogy nem mindig kell majd minden mező a form-ba, ami a táblában definiálva van.
	 * Erre jó a $skipFields cucc. Ha valamiről már fordítási időben is tudod ezt, akkor célszerű a mapping konfigban
	 * már eleve felvenni az ObjectMapping objektumban ezeket!
	 *
	 * Továbbá vannak olyan esetek, amikor a fejlesztő felelőssége konkrét döntést hozni.
	 * Például egy db szinten DBField::TYPE_STRING-ként azonosított mező Form szinten simán lehet "text" de még
	 * "textarea" is... Arról nem is beszélve, hogy akár "select" is lehet... Szóval az oké, hogy ezekre van egy
	 * alap logika, viszont ennek felülírhatónak kell lenni! Erre való a $tableFieldFormFieldMapping, amiben
	 * runtime megteheted ezeket a felülírásokat!
	 *
	 * FONTOS! Minden DBField::TYPE_xxx konstansnál le van írva, hogy azokat a form rész hogyan kezeli!
	 * Konkrét esetekben nézd meg a megfelelő dokumentációját!
	 *
	 * @param string $formName ilyen néven jön létre a definíció, alapból "SiteUser" lesz
	 * @param array $skipFields field nevek tömbje (az objektumban!), amelyeket nem akarunk a form-ra mappelni - ha null, akkor alapból a mapping konfigban az ObjectMapping objektumokban beállított mezőt kapja meg
	 * @param array $tableFieldFormFieldMapping field nevekkel kulcsolt tömb, elemei FormElementInfo objektumok  - segítségével pontosítható, hogy ha egy adott mezőt a default-tól eltérő módon akarunk form-ra mappelni
	 * @return Form a form definíciós objektum, ami még manipulálható, de amúgy készen áll átadása a FormUtil::addForm() metódusának
	 */
	public static function getForm($formName = null, $skipFields = null, $tableFieldFormFieldMapping = null) {
		if(is_null($formName))
		$formName = 'SiteUser';
		if(is_null($skipFields))
		$skipFields = DBSiteUser::getSkipFieldsInForms();
		return DBObject::getForm(DBSiteUser::getDBTable(), $formName, $skipFields, $tableFieldFormFieldMapping);
	}


	/**
	 * Fogja az objektum mezőit, és bepakolja őket egy olyan tömbbe, amit már a FormUtil::fillFormValuesFromObject() fogadni tud.
	 * Ehhez végigmegy a tábla definiált mezőin, majd megpróbálja azokat megtalálni az adott nevű form-ban.
	 * Ha van elem a formban, azt megpróbálja feltölteni. Ha nincs, akkor azzal nem foglalkozik.
	 *
	 * A kihagyott mezők - mindegy mi az oka - egyszerűen nem fognak szerepelni a visszaadott asszociatív tömbben.
	 *
	 * @param string $formName ilyen néven jött létre a definíció - ha nem adod meg, akkor "SiteUser" lesz
	 * @param array $skipFields field nevek tömbje (az objektumban!), amelyeket nem akarunk a form-ra mappelni - ha null, akkor alapból a mapping konfigban az ObjectMapping objektumokban beállított mezőt kapja meg
	 * @param boolean $skipNotSetFields ha true, akkor kihagyja azokat azon oszlopokat, amik az objektum szerint nem tartalmaznak értéket
	 * @return array egy asszociatív tömbe, mely már passzolható a FormUtil::fillFormValuesFromObject() metódusának!
	 */
	public function toFormValues($formName = null, $skipFields = null, $skipNotSetFields = false) {
		if(is_null($formName))
		$formName = 'SiteUser';
		if(is_null($skipFields))
		$skipFields = DBSiteUser::getSkipFieldsInForms();
		return parent::toFormValues(DBSiteUser::getDBTable(), $formName, $skipFields, $skipNotSetFields);
	}


	/**
	 * Adott egy asszociatív tömb, mely a form egy instance-ának az értékeit tartalmazza, azaz a
	 * FormUtil::getFormValues() adta vissza.
	 *
	 * A metódus végigmegy a tömb mezőin, és ha azok szerepelnek a tábla oszlopai között,
	 * és nincsenek felsorolva a $skipFields-ben, akkor megpróbálja az értéket áttölteni az
	 * objektum megfelelő mezőjébe!
	 *
	 * Eközben típus konverziók is történhetnek a form elem típusa és a mező típusa közt.
	 * Ha bárhol a feldolgozás során feloldhatatlan fejlesztői problémába ütközik, akkor logol és küld levelet!
	 * Az ilyen mezők értékét kihagyja!
	 * Ugyanakkor itt létezik a "user error" kérdéskör is, ha a user gépelt hibás adatot a formba! Pl.
	 * beírt valamit, pedig ott egy számnak kéne lennie...
	 * Ezeket a hibákat a mezőnevekkel kulcsolt tömbben kapod vissza, és nyelvesítve!
	 *
	 * @param array $formValues a FormUtil::getFormValues() által visszaadott értékhalmaz - ebből tölti fel az objektum mezőit
	 * @param string $formName ilyen néven jött létre a definíció - ha nem adod meg, akkor "SiteUser" lesz
	 * @param array $skipFields field nevek tömbje (az objektumban!), amelyeket nem akarunk kiolvasni - ha null, akkor alapból a mapping konfigban az ObjectMapping objektumokban beállított mezőt kapja meg
	 * @return FormErrors form hibákat tartalmazó objektum
	 */
	public function fillFromFormValues($formValues, $formName = null, $skipFields = null) {
		if(is_null($formName))
		$formName = 'SiteUser';
		if(is_null($skipFields))
		$skipFields = DBSiteUser::getSkipFieldsInForms();
		return parent::fillFromFormValues(DBSiteUser::getDBTable(), $formValues, $formName, $skipFields);
	}

	private function __________query_db(){
	}


	/**
	 * Proxy metódus.
	 *
	 * @param int $id az objektum azonosítója
	 * @param string $runtimeClassName ilyen class-t kapsz majd vissza - ha nem adod meg, akkor SiteUser típusút
	 * @param array $dbColumnNames a db mezők nevei amiket bekérdez a db-ből - ha nincs megadva, akkor a $dbTable definíció szerinti összes mező jön!
	 * @param int $cacheControl ha null, akkor normál cache működés van, vagy valamelyik DBObject::CACHECONTROL_xxx konstans, ha spéci cache kezelést akarsz
	 * @return SiteUser az objektum, vagy null ha nincs ilyen
	 * @throws Exception hiba esetén nyelvesített exception megy
	 * @see DBObject::getObjectWithKey()
	 */
	public static function getObjectWithKey($id, $dbColumnNames = null, $cacheControl = null, $runtimeClassName = null) {
		if(is_null($runtimeClassName))
		$runtimeClassName = 'SiteUser';
		$dbObject = DBObject::getObjectWithKey($id, DBSiteUser::getDBTable(), $runtimeClassName, 'DBSiteUser', $dbColumnNames, $cacheControl);
		return $dbObject;
	}


	/**
	 * Proxy metódus
	 *
	 * @return SiteUser objektumok tömbje
	 * @throws Exception hiba esetén nyelvesített exception megy
	 * @see DBObject::getAllObjectsFromCache()
	 */
	public static function getAllObjectsFromCache() {
		$objects = DBObject::getAllObjectsFromCache(DBSiteUser::getDBTable(), 'DBSiteUser');
		return $objects;
	}


	/**
	 * Proxy metódus.
	 *
	 * @param int $id az objektum azonosítója
	 * @return SiteUser az objektum, vagy null ha nincs ilyen a cache-ben
	 * @throws Exception hiba esetén nyelvesített exception megy
	 * @see DBObject::getObjectFromCacheWithKey()
	 */
	public static function getObjectFromCacheWithKey($id) {
		$dbObject = DBObject::getObjectFromCacheWithKey($id, DBSiteUser::getDBTable(), 'DBSiteUser');
		return $dbObject;
	}


	/**
	 * Proxy metódus.
	 *
	 * @param array $records a rekordok tömbje
	 * @param string $runtimeClassName ilyen class-t kapsz majd vissza - ha nem adod meg, akkor SiteUser típusút
	 * @param int $cacheControl ha null, akkor normál cache működés van, vagy valamelyik DBObject::CACHECONTROL_xxx konstans, ha spéci cache kezelést akarsz
	 * @return array SiteUser vagy a $runtimeClassName objektumok tömbje abban a sorrendben, ahogy a rekordok voltak
	 * @throws Exception hiba esetén nyelvesített exception megy
	 */
	public static function &getObjectsFromRecords(&$records, $cacheControl = null, $runtimeClassName = null) {
		if(is_null($runtimeClassName))
		$runtimeClassName = 'SiteUser';
		$dbObjects =& DBObject::getObjectsFromRecords($records, DBSiteUser::getDBTable(), $runtimeClassName, 'DBSiteUser', $cacheControl);
		return $dbObjects;
	}

	/**
	 * Proxy metódus.
	 *
	 * @param string $runtimeClassName ilyen class-t kapsz majd vissza - ha nem adod meg, akkor SiteUser típusút
	 * @param DBQueryFilter $filter a filter, ami leírja a lekérdezendő objektumokat - ha nincs megadva akkor jön minden
	 * @param array $orderBy rendezés
	 * @param int $limit ennyi rekordot adjon vissza max
	 * @param array $dbColumnNames a db mezők nevei amiket bekérdez a db-ből - ha nincs megadva, akkor a $dbTable definíció szerinti összes mező jön!
	 * @param int $cacheControl ha null, akkor normál cache működés van, vagy valamelyik DBObject::CACHECONTROL_xxx konstans, ha spéci cache kezelést akarsz
	 * @return array SiteUser vagy a $runtimeClassName objektumok tömbje abban a sorrendben, ahogy a rekordok lejöttek a db-ből
	 * @throws Exception hiba esetén nyelvesített exception megy
	 */
	public static function &getObjects($filter = null, $orderBy = null, $limit = null, $dbColumnNames = null, $cacheControl = null, $runtimeClassName = null) {
		if(is_null($runtimeClassName))
		$runtimeClassName = 'SiteUser';
		$dbObjects =& DBObject::getObjects(DBSiteUser::getDBTable(), $runtimeClassName, 'DBSiteUser', $filter, $orderBy, $limit, $dbColumnNames, $cacheControl);
		return $dbObjects;
	}

	/**
	 * Proxy metódus.
	 *
	 * FONTOS! Ha string mezőket is rendezel, akkor érdemes lehet meghívnod a TextUtil::setLangForStringCmp()
	 * metódusát mielőtt ezt használod, hogy nyelvhelyes sorrendet kapj!
	 *
	 * @param string $runtimeClassName ilyen class-t kapsz majd vissza - ha nem adod meg, akkor SiteUser típusút
	 * @param DBQueryFilter $filter a filter, ami leírja a lekérdezendő objektumokat - ha nincs megadva akkor jön minden
	 * @param array $orderings rendezés, ez kerül átadásra a DBUtil::sortRecordArray() metódusnak
	 * @param int $limit ennyi rekordot adjon vissza max
	 * @param array $dbColumnNames a db mezők nevei amiket bekérdez a db-ből - ha nincs megadva, akkor a $dbTable definíció szerinti összes mező jön!
	 * @param int $cacheControl ha null, akkor normál cache működés van, vagy valamelyik DBObject::CACHECONTROL_xxx konstans, ha spéci cache kezelést akarsz
	 * @return array SiteUser vagy a $runtimeClassName objektumok tömbje a kért sorrendben
	 * @throws Exception hiba esetén nyelvesített exception megy
	 * @see TextUtil::setLangForStringCmp()
	 */
	public static function &getDBUtilSortedObjects($filter = null, $orderings = null, $limit = null, $dbColumnNames = null, $cacheControl = null, $runtimeClassName = null) {
		if(is_null($runtimeClassName))
		$runtimeClassName = 'SiteUser';
		$dbObjects =& DBObject::getDBUtilSortedObjects(DBSiteUser::getDBTable(), $runtimeClassName, 'DBSiteUser', $filter, $orderings, $limit, $dbColumnNames, $cacheControl);
		return $dbObjects;
	}

	private function __________set_get_fields(){
	}


	/**
	 * @return  a mező értéke
	 */
	public function getId() {
		return $this->id;
	}

	/**
	 * @param  $value a mező új értéke
	 */
	public function setId($value) {
		$this->set('id', $value);
	}

	/**
	 * @return  a mező értéke
	 */
	public function getSiteId() {
		return $this->siteId;
	}

	/**
	 * @param  $value a mező új értéke
	 */
	public function setSiteId($value) {
		$this->set('siteId', $value);
	}

	/**
	 * @return string a mező értéke
	 */
	public function getName() {
		return $this->name;
	}

	/**
	 * @param string $value a mező új értéke
	 */
	public function setName($value) {
		$this->set('name', $value);
	}

	/**
	 * @return string a mező értéke
	 */
	public function getLanguage() {
		return $this->language;
	}

	/**
	 * @param string $value a mező új értéke
	 */
	public function setLanguage($value) {
		$this->set('language', $value);
	}

	/**
	 * @return string a mező értéke
	 */
	public function getEmail() {
		return $this->email;
	}

	/**
	 * @param string $value a mező új értéke
	 */
	public function setEmail($value) {
		$this->set('email', $value);
	}

	/**
	 * @return string a mező értéke
	 */
	public function getPassword() {
		return $this->password;
	}

	/**
	 * @param string $value a mező új értéke
	 */
	public function setPassword($value) {
		$this->set('password', $value);
	}

	/**
	 * @return string a mező értéke
	 */
	public function getGender() {
		return $this->gender;
	}

	/**
	 * @param string $value a mező új értéke
	 */
	public function setGender($value) {
		$this->set('gender', $value);
	}

	/**
	 * @return string a mező értéke
	 */
	public function getBirthYear() {
		return $this->birthyear;
	}

	/**
	 * @param string $value a mező új értéke
	 */
	public function setBirthYear($value) {
		$this->set('birthyear', $value);
	}

	/**
	 * @return  a mező értéke
	 */
	public function getType() {
		return $this->type;
	}

	/**
	 * @param  $value a mező új értéke
	 */
	public function setType($value) {
		$this->set('type', $value);
	}

	/**
	 * @return  a mező értéke
	 */
	public function getStatus() {
		return $this->status;
	}

	/**
	 * @param  $value a mező új értéke
	 */
	public function setStatus($value) {
		$this->set('status', $value);
	}

	/**
	 * @return  a mező értéke
	 */
	public function getRights() {
		return $this->rights;
	}

	/**
	 * @param  $value a mező új értéke
	 */
	public function setRights($value) {
		$this->set('rights', $value);
	}

	/**
	 * @return  a mező értéke
	 */
	public function getAttributes() {
		return $this->attributes;
	}

	/**
	 * @param  $value a mező új értéke
	 */
	public function setAttributes($value) {
		$this->set('attributes', $value);
	}

	/**
	 * @return  a mező értéke
	 */
	public function getTexts() {
		return $this->texts;
	}

	/**
	 * @param  $value a mező új értéke
	 */
	public function setTexts($value) {
		$this->set('texts', $value);
	}


}
?>